This invention relates generally to a graphical user interfaces in a computer system and more specifically, to damage handling for rendering zooming objects in zooming graphical interfaces able to manipulate items of information, which may be displayed in multiple levels of magnification to users of computer systems.
The available display screen area on a computer monitor has become increasingly inadequate for certain computer applications in terms of the presentation of the complex information and control options typical in advanced computer systems. In this regard, computing systems of the prior art have attempted to provide various solutions to address the problem of limited display screen area.
For example, windowing systems divide a screen into multiple tiled or overlapping display areas, resembling sheets of paper on a desktop, with one window in the foreground and others in the background. These windows remind the user that other information and control options are readily available to be brought to the foreground at the click of a mouse on an unobscured point in the window containing the desired material. However, such systems allow only a limited number of windows to be open and only the foreground window to be operable at any one time. In addition, information within a window that does not fit on the window""s display screen area must be scrolled using an input device in order to access chosen information. Since objects that a user wants to access are concealed until explicitly opened and scrolled to, systems of this type deprive the user of xe2x80x98peripheralxe2x80x99 vision of all the available information.
Another attempt to increase displayed information and control options is the use of hierarchical menuing through a sequence of display screens, offered to the user as a cascade of submenu windows or a single designated screen area which is overwritten for each submenu. Both of these display methods have significant drawbacks. Typically, advanced computer systems involve complex hierarchical information structures organized into menus representing decision trees. Attempts to maximize the display screen area by abbreviating menuing options create systems less amenable to use by non-experts, requiring extensive training to produce expert users, because, in many cases, the top levels of a menu do not suggest options at sub-levels. Moreover, the graphical representations of large hierarchical structures often occupy multiple display screens, requiring extensive scrolling to access material not visible on the limited display screen. Further, cascaded windows introduce screen clutter and prevent the user from seeing all of the cascaded information simultaneously, while presentation of information in a single designated screen area removes information from the display each time a write operation occurs. Both methods introduce the possibility for a user to lose track of the current location within the menu hierarchy. As an additional drawback to these methods, diversified data collections not easily described by a well structured hierarchy are represented even less adequately.
A somewhat different method for accessing information available on a computer display for providing ease of information access to a user is altering the size of information on a display, i.e. xe2x80x9czoomingxe2x80x9d. However, conventional zooming graphical user interfaces typically implement static hard-coded systems, which are inflexible in various aspects, suffering from limited and inefficient capabilities while lacking portability and modularity. Another facet of prior art zooming graphical user interfaces that reduces such interfaces"" utility is inefficient damage handling. Damage handling refers to the process of re-rendering so that the result of a user manipulation becomes visible. A user may manipulate a zooming object, thereby modifying one or more characteristics thereof and consequently altering a zooming space. Such a manipulation may affect not only the display of the zooming object being manipulated but other zooming objects positioned in the zooming space. For instance, if a particular zooming object is deleted, other zooming objects positioned below the deleted object may now become unobscured and visible. The re-rendering of an entire zooming space in response to such a user manipulation is more computationally intensive than necessary to accomplish the goal of making a user modification visible. Thus the prior art re-renders only those regions of a display which are affected by the user manipulation, limiting the region to be re-rendered to the bounding box of the manipulated object. It should be understood that user manipulation requiring damage handling may take the form of zooming, moving, deleting, or performing other activities on zooming objects in a zooming space.
Calls to the operating system image renderer represent the xe2x80x9cchoke pointxe2x80x9d of a zooming graphical user interface. A region manager of the zooming graphical user interface allows such calls to be minimized in order to increase the robustness of the system hosting interface. The region manager accumulates the coordinates for regions of the display that are in need of re-rendering. At some later time, a damage handling process calculates the resultant display for each region of the display stored in the region manager. The prior art accomplishes damage handling in several basic steps. First, the current bounding box of an object that is to be modified is sent to the region manager. Then, the object is manipulated causing a modification. Next, the object""s modified (i.e., new) bounding box is sent to the region manager. The display parameters for those objects encapsulated by a given bounding box and thereby affected by a modification are calculated when the region manager is flushed during system idle time. In other words, the display parameters for each bounding box stored in the region manager are recalculated and repainted during system idle time. This process typically occurs for each discrete user manipulation to a zooming object (e.g., object coloring, object move, etc.) and may affect objects located on various zooming surfaces. For example, if a zooming object were to be colored and moved, the damage handling would be invoked to accumulate affected regions for the color manipulation and then for the move manipulation.
However, such damage handling still tends to be computationally intensive, thereby resulting in slower system response times, as well as slower refresh frame rates. Intense computational demands placed on the computer system hosting the zooming graphical user interface are manifest as sluggish command response and attendant degradation of various aspects of the computer system operation. Consequently, the effectiveness of not only the zooming graphical user interface but that of other applications active on the computer system is reduced. These limitations and limited capabilities form serious impediments to the widespread dissemination and efficient utilization of complex zooming computing systems. Thus, comprehensive utilization of zooming graphical user interfaces is discouraged.
Accordingly, it is an objective of the invention to provide a zooming graphical user interface that provides improved flexibility and more efficient functionality. To that end, a computer interface is described that provides for the manipulation of objects using a zooming graphical user interface implemented with an object-oriented platform-independent programming language. The zooming graphical user interface is employed by object-oriented drawing applications and other zooming applications that logically organize graphical data. Graphical data in the interface of the invention is not static but is displayed as a zooming universe of graphical objects which may be manipulated with interactive input devices causing corresponding alteration to the graphical data defining the manipulated graphical object. The interface permits a user to easily pick objects in a zooming universe for display at an altered level of magnification (and, accordingly, a re-rendering of a portion of the zooming space), thereby allowing the user to quickly hone in on desired information. Other user manipulation activities such as moving, adding, deleting, or coloring a zooming object similarly require a re-rendering of a portion of the zooming space to make the result of user manipulation apparent (i.e., visible).
The damage handling process of the invention efficiently calculates display parameters for regions of a zooming space affected by user interaction with zooming objects. According to the invention, the entire zooming space need not be re-rendered in response to a user manipulation in order to make the resultant modification visible to the user. Re-rendered areas of the zooming space are selectively limited to those regions of the display screen that are affected by a user modification. Furthermore, calculation of the parameters for the modified display is executed only after a series of manipulation operations is completed, thereby reducing the concomitant data processing demand on systems resources.
The zooming engine of the invention stores, as part of each zooming object, certain snapshot dataxe2x80x94i.e., a copy of certain visual characteristics of the graphical objectxe2x80x94such as whether and where the object is visible. The snapshot data for the object includes but is not necessarily limited to variables that define a bounding box, a minimum displayable zoom level, a maximum displayable zoom level, and a display layer identifier. The layer identifier provides semantic ordering of objects positioned on a zooming surface. Zoom levels indicate the range of levels at which a zooming object is visible. The bounding box defines the smallest of a predetermined geometric shape that circumscribes the object and is used to determine the occurrence of user interaction with a zooming object. It should be understood that any number of shaped bounding boxes may be used by the invention, although the preferred bounding box is a rectangle.
The first user manipulation of a zooming object in the interface of the invention causes snapshot data to be stored for the zooming object. Subsequently, a series of manipulation operations which may result in a change to visible characteristics of the zooming object may be undertaken. The damage handling method of the invention, which determines the region of the zooming space that must be re-rendering to make the modifications visible, is explicitly invoked after the series of manipulations is complete. The general damage handling process first determines that a visual characteristic of the object was modified by comparison of snapshot data and the corresponding current data for the object. A bounding box that circumscribes the bounding boxes of the snapshot data and the current object data is then calculated. This bounding box defines the repaint region according to the damage handling process of the invention and modified display parameters for this region are calculated. The singular calculation of display parameters for this selectively limited repaint region reduces data processing and results in faster system response times and refresh frame rates as compared to prior art zooming graphical user interfaces.
In accordance with the singular calculation aspect of the invention, the zooming graphical user interface may process one or more sets of modifications made to the displayed zooming space before making any of the modifications apparent. A zooming object being manipulated by a user may be modified multiple times (or in multiple respects) before the user finishes manipulating the object and requires that the object be rendered. Instead of calculating a modified display region automatically in response to each of several related modifications, an entire set of changes may be processed completely prior to calculation of the display region to be re-rendering.
Coordinates for regions of display affected by a modification are buffered by a region manager. However, in order to make such modifications visible to a user, a damage method that renders the zooming object (or a variation that causes the displayed view of the zooming space to be re-rendered) by way of the operating system image renderer must be explicitly called. The method determines a single affected region circumscribing the accumulated regions prior to invoking the image render. The described approach reduces the number of invocations made of the operating system rendering interface. The process of the invention reduces both the number of times the objects"" bounding box must be calculated and the number of regions which are accumulated by the region manager prior to a repaint of the display. This damage handling method serves to limit the processing demands placed on the computer system hosting the zooming graphical user interface.